/***
 * @Author:xxx
 * @Date:2020-11-07 20:48:34
 * @LastModifiedBy:xxx
 * @Last Modified time:2020-11-07 20:48:34
 */

// reducer函数模块：根据当前的state 和 指定的action 返回一个新的state

import { combineReducers } from 'redux';
import { getUser,getDefaultMb } from '../utils/storageUtils';
import {RECEIVE_USER,SHOW_ERROR_MSG,RESET_USER,RECEIVE_CURVES_INTO_DAOS,
  ADD_LINE_DAO,ADD_DEPTH_DAO,ADD_YX_DAO,DELETE_DAO,DELECT_CURVE_IN_DAO,ADD_CURVE_IN_DAO,RECEIVE_SELECTED_CURVES,EDIT_DEPTH_DATA,
  RECEIVE_DAOS_MB,EDIT_CURVE_INFO,RECEIVE_DOC,RECEIVE_MB,EDIT_DOC_INFO,ADD_YX_DATA,
  ADD_NEW_CURVE_IN_DAO,INIT_DAOSDATALIST,INIT_DOCDATA,INIT_MBDATA,RECEIVE_DEFAULT_MB,REPLACE_NEW_CURVES,UPDATE_DRAGGABLE,GET_CURVES_COUNT,CANCEL_SELECTED,RETURN_INIT,
  IS_UPDATE_PAGES,DRAG_CURVE_DATA,UPDATE_DAO_ORDER,SAVE_VIDEO_CLICK_YDATA,SAVE_VIDEO_DIRECTION,SAVE_VIDEO_MARKLINE,
  RECEIVE_DAOS_MB1,EDIT_DEPTH_DATA1,RECEIVE_CURVES_INTO_DAOS1,RECEIVE_SELECTED_CURVES1,RETURN_INIT1,EDIT_CURVE_INFO1,UPDATE_DAO_ORDER1,DELECT_CURVE_IN_DAO1,ADD_CURVE_IN_DAO1,INIT_DAOSDATALIST1,
  RECEIVE_DAOS_MB2,EDIT_DEPTH_DATA2,RECEIVE_CURVES_INTO_DAOS2,RECEIVE_SELECTED_CURVES2,RETURN_INIT2,EDIT_CURVE_INFO2,UPDATE_DAO_ORDER2,DELECT_CURVE_IN_DAO2,ADD_CURVE_IN_DAO2,INIT_DAOSDATALIST2,REPLACE_NEW_CURVES2,
  SET_CURVETYPE,SET_CURVE1,SET_CURVE2,SET_COLOR,SET_CURVE,CHANGE_TAG,SET_ORIGIN_DATA,
  SET_GRID_NUMBER,SET_CHART_ZOOM,
  ADD_MB_LINE_DAO,ADD_MB_DEPTH_DAO,ADD_MB_YX_DAO,DELETE_MB_DAO,
  EDIT_DAO_DATALIST_INFO,
  EDIT_DAO_DATALIST_1_INFO,
  REPLACE_DOCDATA_NEW_CURVES,
  INIT_TWODIMDATA,
  EDIT_MB_DAO_INFO,//编辑mbData reducer中的道信息 (和下面信息是同步的，可能后面还需要同步DaodataList1，DaodataList2)
  //EDIT_MB_DAOLIST_INFO//编辑DaodataList reducer中的道信息
  DO_NULL,
  SET_CHINAMAP,SET_ORGID
} from './action-types';



import { message } from 'antd';

// import ActionButton from 'antd/lib/modal/ActionButton';    




// 管理 user 状态数据的reducer: 
const initUser = getUser();
function user(state = initUser, action){   
  switch(action.type){
    case RECEIVE_USER:
      return action.user;
    case SHOW_ERROR_MSG:
      const errorMsg = action.errorMsg;
      return {...state,errorMsg};   // 在原有数据的基础上，加一个errorMsg， 千万不要直接修改原本的state！！！
    case RESET_USER:
      return {};
    default:
      return state;
  }  
}


//-------------------------------------------------------------------------------数据处理-----------------------------------------------------------------------------------------

const initdoc = {};
function docData(state = initdoc, action){   // 当前文件
  switch(action.type){
    case RECEIVE_DOC:
      console.log("当前reducer中文件",action.data);
      return action.data;
    case EDIT_DOC_INFO:  // 编辑文件 的头信息
      if(state.doc_type === '纯数据文件'){
        console.log("数据")
        if(action.data.info_name === "钻孔号"){
          state.drill_id = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "仪器型号"){
          state.measuring_tool = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "地点"){
          state.measuring_address = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量深度"){
          state.measuring_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "探管型号"){
          state.ground_tube_type = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量时间"){
          state.measuring_time = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "开孔倾角"){
          state.open_angle = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "测井方向"){
          state.logging_direction = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量员"){
          state.operator = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "开孔方位"){
          state.open_position = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "起始深度"){
          state.start_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "处理时间"){
          state.handle_time = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "磁偏角"){
          state.declination = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "终止深度"){
          state.end_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "处理员"){
          state.handle_person = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "勘探线方位"){
          state.prospect_line_position = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "采样间隔"){
          state.sample_interval = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "单位"){
          state.company = action.data.info_value
          return {...state};
        }
      }else if(state.doc_type === '绘图文件'){
        console.log("绘图")
        if(action.data.info_name === "钻孔号"){
          state.docData.drill_id = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "仪器型号"){
          state.docData.measuring_tool = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "地点"){
          state.docData.measuring_address = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量深度"){
          state.docData.measuring_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "探管型号"){
          state.docData.ground_tube_type = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量时间"){
          state.docData.measuring_time = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "开孔倾角"){
          state.docData.open_angle = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "测井方向"){
          state.docData.logging_direction = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "测量员"){
          state.docData.operator = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "开孔方位"){
          state.docData.open_position = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "起始深度"){
          state.docData.start_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "处理时间"){
          state.docData.handle_time = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "磁偏角"){
          state.docData.declination = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "终止深度"){
          state.docData.end_depth = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "处理员"){
          state.docData.handle_person = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "勘探线方位"){
          state.docData.prospect_line_position = action.data.info_value 
          return {...state};
        }else if(action.data.info_name === "采样间隔"){
          state.docData.sample_interval = action.data.info_value
          return {...state};
        }else if(action.data.info_name === "单位"){
          state.docData.company = action.data.info_value
          return {...state};
        }
      }
    case INIT_DOCDATA:
      return action.data;
    case REPLACE_DOCDATA_NEW_CURVES:
      if(action.docType==="纯数据文件"){
        let newCurves = action.data;
        state.curves&&state.curves.map(item=>{
          newCurves.map(el=>{
            if(el.curve_id===item.curve_id){
              item.xData=el.xData;
            }
          })
        })
      }else if(action.docType=="绘图文件"){
        let newCurves = action.data;
        state.docData.curves&&state.docData.curves.map(item=>{
          newCurves.map(el=>{
            if(el.curve_id===item.curve_id){
              item.xData=el.xData;
            }
          })
        })
      }
      return state;
    default:
      return state;
  }
}

const initmb = {};
var maxMbId = 1;
function mbData(state = initmb, action){   // 当前模板
  const newState=JSON.parse(JSON.stringify(state));
  // console.log(action)
  switch(action.type){
    case RECEIVE_MB:
      return {...action.data};
    case INIT_MBDATA:
      return {...action.data};

    case EDIT_MB_DAO_INFO:
      newState.mb_dao.map((item)=>{
        if(item.id===action.data.id){
          item.vgridNumber=action.data.vgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.vlinetype=action.data.vlineType;
          item.hgridNumber=action.data.hgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.hlinetype=action.data.hlineType;
          item.dao_width=action.data.dao_width;
        }
      })    
      return newState;

    case ADD_MB_LINE_DAO:  // 添加线性道？？？？
      //const lineDao = [...state]
      newState.mb_dao.map((item) => {  // 找出最大的 id
        if(item.id >= maxMbId){
          maxMbId = item.id
        }
      })
      newState.mb_dao.push({
        id: maxMbId + 1,                  
        title: '道',            
        type:'line-dao',   
        curves: [] ,
        dao_width: 200,
        hgridNumber:5,
        vgridNumber:10,
        hlinetype:'solid',
        vlinetype:'solid'
      })
      return newState;
    case ADD_MB_DEPTH_DAO:  // 添加深度道？？？？
      newState.mb_dao.map((item) => {  // 找出最大的 id
        if(item.id >= maxMbId){
          maxMbId = item.id
        }
      })
      newState.mb_dao.push({
        id: maxMbId + 1,                  
        title: '深度',            
        type:'depth-dao',       
        curves: []  
      })
      return newState;
    case ADD_MB_YX_DAO:  // 添加岩性道？？？？
      var isAddYxDao = true;
      newState.mb_dao.map((item) => {  // 找出最大的 id
        if(item.id >= maxMbId){
          maxMbId = item.id
        }
      })
      newState.mb_dao.map((item1) => {   // 规定模板中只能有一个岩性道
        if(item1.type === "yx-dao"){
          isAddYxDao = false;
          message.error("模板中已存在岩性道！");
          return false;
        }
      });
      if(isAddYxDao){   // isAddYxDao:是否添加岩性道
        newState.mb_dao.push({
          id: maxMbId + 1,                  
          title: '岩性道',            
          type:'yx-dao',  
          curves: [{
            type: 'yx',          // 每条岩性道有且仅有一条曲线
            id: 'yx1',
            curve_id: null,
            curve_name: 'yx1',
            title: '岩性12',        // 曲线 名称
            color: null,
            left_data: null,
            right_data: null,
            width: null,
            xData:[]
          }]  
        })
      }
      // console.log("reducer岩性",state)
      return newState;
    case DELETE_MB_DAO:  // 
      newState.mb_dao.map((item,index) => {
        if(item.id === action.daoId){
          return newState.mb_dao.splice(index, 1);  
        }
      });
      return newState;
    default:
      return state;
  }
}

const initdefaultmb = getDefaultMb();
function defaultmbData(state = initdefaultmb, action){   // 默认模板
  switch(action.type){
    case RECEIVE_DEFAULT_MB:
      //console.log("默认模板",action.data);
      return action.data;
    default:
      return state;
  }
}




// 道数据 的reducer： 该曲线集合 用来 在道中展示
/**
 * 疑问？？？？：渲染模板（道）、删除道、添加道 等功能 必须直接修改state 才能正常渲染，
 *      按常理不应该直接修改state，但不直接修改state，无法更新视图
 *      目前修改为了 直接改变state值，但不懂原理，有待改进！！！！！
 */
const initDaosDataList = [];   // []
var maxId = 1;
function daosDataList(state = initDaosDataList, action){      //状态改变后，页面不重新渲染：为监听到到新旧state的变化
  switch(action.type){
    case RECEIVE_DAOS_MB:   // 获取模板 或 绘图文件，并显示，渲染到页面上 ？？？？
      state.splice(0,state.length);
      action.daoMb.map((item)=>state.push(item));
      console.log("reducer获取模板",action,action.daoMb);
      return state; // action.daoMb
    case RECEIVE_CURVES_INTO_DAOS:   // 将曲线放入道中：纯数据文件中的曲线数据 放入道中，通过curve_name匹配？？？？？
      //const curvesMb = [...state];  
      const curvesList = action.data;  // 获取到的新 曲线数组
      curvesList.map((item1) => {   // 匹配曲线名，并将 数据写入模板
        state.map((item2) => {
          if(item2.curves){
            item2.curves.map((item3) => {
              if(item1.curve_name === item3.curve_name){
                item3.xData = item1.xData;
                item3.curve_id = item1.curve_id;  // 默认id为曲线ing，匹配成功后，改为真实曲线id
              }
            })
          }
        })
      }) 
      return state;   //[...state]

    case UPDATE_DAO_ORDER:  // 更新 道 的顺序（拖拽道）
      state = action.data;
      return state;

    //编辑docList 的道属性
    case  EDIT_DAO_DATALIST_INFO:
      state.map((item)=>{
        if(item.id==action.data.id){
          item.vgridNumber=action.data.vgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.vlinetype=action.data.vlineType;
          item.hgridNumber=action.data.hgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.hlinetype=action.data.hlineType;
          item.dao_width=action.data.dao_width;
        }
      })    
      return state;

    case EDIT_CURVE_INFO:   // 修改 曲线属性，并渲染  vvvvv
      state.map((item1) => {
        if(item1.curves){
          item1.curves.map((item) => {
            if(item.id === action.data.id){
              item.curve_name = action.data.curve_name;
              item.title = action.data.title;
              item.left_data = action.data.left_data;
              item.right_data = action.data.right_data;
              item.width = action.data.width;
              item.color = action.data.color;
              item.line_type=action.data.line_type;
              item.curve_unit=action.data.curve_unit;
            }
          })
        }
      })
      //console.log("newstate",[...state]); 
      return state;   //[...state]

    case ADD_YX_DATA:   // 用户添加岩性信息
      state.map((item) => {
        if(item.type === "yx-dao"){   // 每条岩性道，自带一条曲线，有且仅有一条。
          item.curves[0].xData.push(action.data)
        }    
      })
      console.log("岩性",state,action.data);  
      return state;
    case DELECT_CURVE_IN_DAO:   // 从道中删除曲线 
      return action.data;
    case ADD_CURVE_IN_DAO:   // 往道中添加曲线
      return action.data; 

    case ADD_LINE_DAO:  // 添加线性道？？？？
      //const lineDao = [...state]
      state.map((item) => {  // 找出最大的 id
        if(item.id >= maxId){
          maxId = item.id
        }
      })
      state.push({
        id: maxId + 1,                  
        title: '道',            
        type:'line-dao',   
        curves: [] ,
        dao_width: 200,
        hgridNumber:5,
        vgridNumber:10,
        hlinetype:'solid',
        vlinetype:'solid'
      })
      return state;
    case ADD_DEPTH_DAO:  // 添加深度道？？？？
      state.map((item) => {  // 找出最大的 id
        if(item.id >= maxId){
          maxId = item.id
        }
      })
      state.push({
        id: maxId + 1,                  
        title: '深度',            
        type:'depth-dao',       
        curves: []  
      })
      return state;
    case ADD_YX_DAO:  // 添加岩性道？？？？
      var isAddYxDao = true;
      state.map((item) => {  // 找出最大的 id
        if(item.id >= maxId){
          maxId = item.id
        }
      })
      state.map((item1) => {   // 规定模板中只能有一个岩性道
        if(item1.type === "yx-dao"){
          isAddYxDao = false;
          message.error("模板中已存在岩性道！");
          return false;
        }
      });
      if(isAddYxDao){   // isAddYxDao:是否添加岩性道
        state.push({
          id: maxId + 1,                  
          title: '岩性道',            
          type:'yx-dao',  
          curves: [{
            type: 'yx',          // 每条岩性道有且仅有一条曲线
            id: 'yx1',
            curve_id: null,
            curve_name: 'yx1',
            title: '岩性12',        // 曲线 名称
            color: null,
            left_data: null,
            right_data: null,
            width: null,
            xData:[]
          }]  
        })
      }
      // console.log("reducer岩性",state)
      return state;
    case DELETE_DAO:  // 删除道？？？？
      state.map((item,index) => {
        if(item.id === action.daoId){
          return state.splice(index, 1);  
        }
      });
      return state;
    case ADD_NEW_CURVE_IN_DAO:  // 将新曲线添加到道（模板）中
      state[0].curves.push({
        color: 'red',     // 设置曲线颜色
        curve_id: action.curve_id,  // 在没有数据时，和曲线名相同，有数据以后更换为数据的id
        curve_name: action.data,   // 曲线名：在同一模板（文件）中唯一
        id:  action.curve_id,    //String(action.curvesCount+1), 
        left_data: 0.0,        // 曲线x轴 坐标范围（左值：最小值）
        right_data: 100.0,     // 曲线x轴 坐标范围（右值：最大值）
        title: action.data,        // 曲线 名称
        type: 'curve',          // 曲线类型（默认curve，不需要改变）
        width: 1,           // 设置曲线宽度
        xData: action.xData
      });
      //console.log("添加曲线成功？",[...state]);
      return state;  //[...state]
    case DRAG_CURVE_DATA:   // 拖拽完曲线后 更新/重置 曲线的 xdata
      state.map((item1) => {   // item1：道
        if(item1.curves){
          item1.curves.map((item2) => {  // item2： 道中的曲线
            if(item2.curve_id === action.data.curve_id){
              item2.xData = action.data.xdata;  // 更新
            }
          })
        }
      })
      return state;
    case REPLACE_NEW_CURVES:   // 处理完成后获取的新曲线进行更新替换 vvvvvvv
      let newCurves = action.data;   // 修改后的曲线列表[]
      // if(action.data.docType === "纯数据文件"){
      //   newCurves = action.data.curves;
      // }else if(action.data.docType === "绘图文件"){
      //   newCurves = action.data.docData.curves;
      // }
      state.map((item1) => {   // item1：道
        if(item1.curves){
          item1.curves.map((item2) => {  // item2： 道中的曲线
            newCurves.map((item3) => {  // item3： 修改后的曲线
              if(item2.curve_id === item3.curve_id){
                item2.xData = item3.xData;  // 曲线匹配上以后，将更新后的item3赋值给 item2 进行更新；
              }
            })
          })
        }
      })
      return [...state];
    case INIT_DAOSDATALIST:
      return action.data;
    default:
      return state;
  }
}

//曲线处理页面的统一深度 的reducer
const initdepthData = {min:0,max:110,interval:0.1};
function generateData(min,max,interval) {
    let data = [];
    let i =0
    for (i = min; i < max; i+=interval) {   //i+=0.1
      data.push(i.toFixed(2));  
    }
    i +=interval;
    data.push(i.toFixed(2));  
    return data;
  }
function depthDataa(state = generateData(initdepthData.min,initdepthData.max,initdepthData.interval), action){   // 数据处理页面的 深度
  switch(action.type){
    case EDIT_DEPTH_DATA:
      console.log("dataaa",action);
      return generateData(parseInt(action.data.min) ,Math.ceil(action.data.max) ,action.data.interval);
    default:
      return state;
  }
}




// 选中的曲线集合 的reducer： 单击选中的曲线，对该集合中的曲线进行预处理
const initSelectedCurves = [];
function selectedCurves(state = initSelectedCurves, action){  
  switch(action.type){  
    case RECEIVE_SELECTED_CURVES:
      var isTure = false;
      const newState = [...state];
      //console.log("lala",newState)
      newState.map((item,index) => {
        if(item.curve_id === action.data.curve_id){
          isTure = true;
          return newState.splice(index,1);
        }
      });
      if(!isTure){
        newState.push(action.data);
      }
      return newState;
    case RETURN_INIT:
      return action.data;
    default:
      return state;
  }
}

// 取消曲线的选中状态： 点击导出图片时，自动取消所有曲线的选中状态
const initCancelSelected = false;
function cancelSelected(state = initCancelSelected, action){  
  switch(action.type){
    case CANCEL_SELECTED:
      console.log("取消选中reducer",action.data)
      return action.data;
    default:
      return state;
  }
}

const initIsDraggable = [];
function isDraggable(state = initIsDraggable, action){   // 是否可以人工绘制
  switch(action.type){
    case UPDATE_DRAGGABLE: 
      var isTure = false;
      const newState = [...state];
      newState.map((item,index) => {
        if(item.curve_id === action.data.curve_id){
          isTure = true;
          return newState.splice(index,1);
        }
      });
      if(!isTure){
        newState.push(action.data);
      } 
      return newState;
    default:
      return state;
  }
}

const initVideoClickYdata = 0;
function videoClickYdata(state = initVideoClickYdata, action){   // 用户点击曲线的点坐标（y坐标）：用于同步视频播放
  switch(action.type){
    case SAVE_VIDEO_CLICK_YDATA: 
      return action.data;
    default:
      return state;
  }
}

const initVideoDirection = true;
function videodirection(state = initVideoDirection, action){   // 视频同步：正向同步true，反向同步false
  switch(action.type){
    case SAVE_VIDEO_DIRECTION: 
      return action.data;
    default:
      return state;
  }
}

const initVideoMarkLine = 0;   // 视频同步时的标记线 位置
function videoMarkline(state = initVideoMarkLine, action){   
  switch(action.type){
    case SAVE_VIDEO_MARKLINE: 
      return action.data;
    default:
      return state;
  }
}


const initCurvesCount = 0;
function curvesCount(state = initCurvesCount,action){   // 获取计算好的最大曲线数，并更新各个页面
  switch(action.type){
    case GET_CURVES_COUNT:
      return action.data;
    default:
      return state;
  }
}

const initUpdatePages = false;
function updatePages(state = initUpdatePages,action){  // 实时更新页面
  switch(action.type){
    case IS_UPDATE_PAGES:
      return action.data;
    default:
      return state;
  }
}


//----------------------------------------------------------------------------- 二维、三维数据展示---------------------------------------------------------------------------------------------
const initDaosDataList1 = [];   // []
function daosDataList1(state = initDaosDataList1, action){      //状态改变后，页面不重新渲染：为监听到到新旧state的变化
  switch(action.type){
    case RECEIVE_DAOS_MB1:   // 获取模板 或 绘图文件，并显示，渲染到页面上 ？？？？
      state.splice(0,state.length);
      action.daoMb.mb_dao.map((item)=>state.push(item));
      // console.log("数据对比获取模板",state,action.daoMb.mb_dao);  
      return [...state]; // action.daoMb
    case RECEIVE_CURVES_INTO_DAOS1:   // 将曲线放入道中：纯数据文件中的曲线数据 放入道中，通过curve_name匹配？？？？？ 
      // state.map((item) => {
      //   if(item.curves){
      //     item.curves.map((item1) => {
      //       item1.xData = [];
      //       item1.curve_id = null;
      //     })
      //   }
      // });    
    // 填入新数据
      const curvesList = action.data;  // 获取到的新 曲线数组
      // console.log("拿到数据",state);
      curvesList.map((item1) => {   // 匹配曲线名，并将 数据写入模板
        state.map((item2) => {
          if(item2.curves){
            item2.curves.map((item3) => {
              if(item1.curve_name === item3.curve_name){
                item3.xData = item1.xData;
                item3.curve_id = item1.curve_id;  // 默认id为曲线ing，匹配成功后，改为真实曲线id
              }
            })
          }
        })
      }) 
      return state;   //[...state]
    case UPDATE_DAO_ORDER1:  // 更新 道 的顺序（拖拽道）
      state = action.data;
      return state;
    case EDIT_CURVE_INFO1:   // 修改 曲线属性，并渲染  vvvvv
      state.map((item1) => {
        if(item1.curves){
          item1.curves.map((item) => {
            if(item.id === action.data.id){
              item.curve_name = action.data.curve_name;
              item.title = action.data.title;
              item.left_data = action.data.left_data;
              item.right_data = action.data.right_data;
              item.width = action.data.width;
              item.color = action.data.color;
              item.line_type=action.data.line_type;
              item.curve_unit=action.data.curve_unit;
            }
          })
        }
      })
      //console.log("newstate",[...state]); 
      return [...state];   //[...state]
    //编辑docList1 的道属性
    case  EDIT_DAO_DATALIST_1_INFO:
      state.map((item)=>{
        if(item.id==action.data.id){
          item.vgridNumber=action.data.vgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.vlinetype=action.data.vlineType;
          item.hgridNumber=action.data.hgridNumber; //列栅格 放置在mb_dao数据的每个dao中
          item.hlinetype=action.data.hlineType;
          item.dao_width=action.data.dao_width;
        }
      })    
      return state;
    case DELECT_CURVE_IN_DAO1:   // 从道中删除曲线 
      return action.data;
    case ADD_CURVE_IN_DAO1:   // 往道中添加曲线 
      return action.data; 
    case INIT_DAOSDATALIST1:
      return action.data;
    default:
      return state;
  }
}

// //统一深度 的reducer
const initdepthData1 = {min:0,max:110,interval:0.1};
function generateData1(min,max,interval) {
    let data = [];
    for (let i = min; i <= max; i+=interval) {   //i+=0.1
      data.push(i.toFixed(2));  
    }
    return data;
  }
function depthDataa1(state = generateData1(initdepthData1.min,initdepthData1.max,initdepthData1.interval), action){   // 数据处理页面的 深度
  switch(action.type){
    case EDIT_DEPTH_DATA1:
      // console.log("数据对比深度",generateData1(action.data.min,action.data.max));
      return generateData1(action.data.min,action.data.max,action.data.interval);
    default:
      return state;
  }
}

// // 选中的曲线集合 的reducer：
const initSelectedCurves1 = [];
function selectedCurves1(state = initSelectedCurves1, action){  
  switch(action.type){
    case RECEIVE_SELECTED_CURVES1:
      var isTure = false;
      const newState = [...state];
      //console.log("lala",newState)
      newState.map((item,index) => {
        if(item.curve_id === action.data.curve_id){
          isTure = true;
          return newState.splice(index,1);
        }
      });
      if(!isTure){
        newState.push(action.data);
      }
      return newState;
    case RETURN_INIT1:
      return action.data;
    default:
      return state;
  }
}

//二维数据展示侧边向展示页面传输的曲线类型，选中曲线ID,颜色

const initTwoDimData = {
  curveType:'',
  color1:['red','orange','yellow','green'],
  color11:['green','yellow','orange','red'],
  color2:'blue',
  selectedCurve1:'',
  selectedCurve2:''  
};
function twoDimData(state = initTwoDimData, action){  
  switch(action.type){
    case INIT_TWODIMDATA:
      return initTwoDimData;
    case SET_CURVETYPE:
      state['curveType']=action.data;
      return {...state};
    case SET_CURVE1:
      state['selectedCurve1']=action.data;
      return {...state};
    case SET_CURVE2:
      state['selectedCurve2']=action.data;  
      return {...state};
    case SET_COLOR:
      state['color1']=action.data[0];
      state['color11']=action.data[1];
      state['color2']=action.data[2];
      return {...state};
    default:
      return state;
  }
}
//三维数据展示侧边向页面传输的曲线，选中曲线ID
const initThreeDimData = {
  selectedCurve:'' ,
  tag:'' 
};
function threeDimData(state = initThreeDimData, action){  
  switch(action.type){
    case SET_CURVE:
      state['selectedCurve']=action.data;
      return {...state};
    case CHANGE_TAG:
      state['tag']=action.data;
      return {...state};
    default:
      return state;
  }
}

// 换页时，清空侧边栏
const initIsDoNull = false;
function isDoNull(state = initIsDoNull,action){
  switch(action.type){
    case DO_NULL:
      return action.data;
    default:
      return state;
  }
}
//-------------------------------------------------原始数据展示---------------------------
const initOriginData = {
  originData:'' 
};
function OriginData(state = initOriginData, action){  
  switch(action.type){
    case SET_ORIGIN_DATA:
      state['originData']=action.data;
      state['header']=action.header;
      return {...state};
    default:
      return state;
  }
}
//----------------------------------------------------------------------------- 数据对比---------------------------------------------------------------------------------------------
const initDaosDataList2 = [];   // []
function daosDataList2(state = initDaosDataList2, action){      //状态改变后，页面不重新渲染：为监听到到新旧state的变化
  switch(action.type){
    case RECEIVE_DAOS_MB2:   // 获取模板 或 绘图文件，并显示，渲染到页面上 ？？？？
      state.splice(0,state.length);
      action.daoMb.map((item)=>state.push(item));
      //console.log("数据对比获取模板",state,action.daoMb);
      return [...state]; // action.daoMb
    case RECEIVE_CURVES_INTO_DAOS2:   // 将曲线放入道中：纯数据文件中的曲线数据 放入道中，通过curve_name匹配？？？？？
      //const curvesMb = [...state];  
      const curvesList = action.data;  // 获取到的新 曲线数组
      //console.log("拿到数据",curvesList,state);
      curvesList.map((item1) => {   // 匹配曲线名，并将 数据写入模板
        state.map((item2) => {
          if(item2.curves){
            item2.curves.map((item3) => {
              if(item1.curve_name === item3.curve_name){
                item3.xData = item1.xData;
                item3.curve_id = item1.curve_id;  // 默认id为曲线ing，匹配成功后，改为真实曲线id
              }
            })
          }
        })
      }) 
      return [...state];   //[...state]
    case UPDATE_DAO_ORDER2:  // 更新 道 的顺序（拖拽道）
      state = action.data;
      return state;
    case EDIT_CURVE_INFO2:   // 修改 曲线属性，并渲染  vvvvv
      state.map((item1) => {
        if(item1.curves){
          item1.curves.map((item) => {
            if(item.id === action.data.id){
              item.curve_name = action.data.curve_name;
              item.title = action.data.title;
              item.left_data = action.data.left_data;
              item.right_data = action.data.right_data;
              item.width = action.data.width;
              item.color = action.data.color;
              item.line_type=action.data.line_type;
              item.curve_unit=action.data.curve_unit;
            }
          })
        }
      })
      //console.log("newstate",[...state]); 
      return [...state];   //[...state]
    case DELECT_CURVE_IN_DAO2:   // 从道中删除曲线 
      return action.data;
    case ADD_CURVE_IN_DAO2:   // 往道中添加曲线
      return action.data; 
    case REPLACE_NEW_CURVES2:   // 处理完成后获取的新曲线进行更新替换 vvvvvvv
      let newCurves = action.data;   // 修改后的曲线列表[]
      state.map((item1) => {   // item1：道
        if(item1.curves){
          item1.curves.map((item2) => {  // item2： 道中的曲线
            newCurves.map((item3) => {  // item3： 修改后的曲线
              if(item2.curve_id === item3.curve_id){
                item2.xData = item3.xData;  // 曲线匹配上以后，将更新后的item3赋值给 item2 进行更新；
              }
            })
          })
        }
      })
      return [...state];
    case INIT_DAOSDATALIST2:
      return action.data;
    default:
      return state;
  }
}

//统一深度 的reducer
const initdepthData2 = {min:0,max:110,interval:0.1};
function generateData2(min,max,interval) {
    let data = [];
    for (let i = min; i <= max; i+=interval) {   //i+=0.1
      data.push(i.toFixed(2));  
    }
    return data;
  }
function depthDataa2(state = generateData2(initdepthData2.min,initdepthData2.max,initdepthData2.interval), action){   // 数据处理页面的 深度
  switch(action.type){
    case EDIT_DEPTH_DATA2:
      console.log("数据对比深度",generateData2(action.data.min,action.data.max));
      return generateData2(parseInt(action.data.min) ,Math.ceil(action.data.max) ,action.data.interval);
    default:
      return state;
  }
}

// 选中的曲线集合 的reducer：
const initSelectedCurves2 = [];
function selectedCurves2(state = initSelectedCurves2, action){  
  switch(action.type){
    case RECEIVE_SELECTED_CURVES2:
      var isTure = false;
      const newState = [...state];
      //console.log("lala",newState)
      newState.map((item,index) => {
        if(item.curve_id === action.data.curve_id){
          isTure = true;
          return newState.splice(index,1);
        }
      });
      if(!isTure){
        newState.push(action.data);
      }
      return newState;
    case RETURN_INIT2:
      return action.data;
    default:
      return state;
  }
}
//-------------------------------------------------数据处理-栅格配置---------------------------
const initGridData = {
  vgridNumber:10,
  hgridNumber:5,
  vlinetype:'solid', 
  hlinetype:'solid', 
  chartZoom: 50
};

function gridConfig(state = initGridData, action){  
  const newState=JSON.parse(JSON.stringify(state));
  switch(action.type){
    case SET_GRID_NUMBER:
      newState.vgridNumber=action.data.vgridNumber;
      newState.hgridNumber=action.data.hgridNumber;
      newState.vlinetype=action.data.vlineType;
      newState.hlinetype=action.data.hlineType;
      return newState;
    case SET_CHART_ZOOM:
      newState.chartZoom=action.data.chartZoom;
      return newState;
    default:
      return newState;
  }
}


let initChinaMap={
  chinaMap:'/',
  org_id:''
}
function hasChinaMap(state = initChinaMap, action){  
  const newState=JSON.parse(JSON.stringify(state));
  switch(action.type){
    case SET_CHINAMAP:
      console.log(action)
      newState.chinaMap=action.data.chinaMap;
      return newState;
    case SET_ORGID:
      console.log(action)
      newState.org_id=action.data.org_id;
      return newState;
    default:
      return newState;
  }
}





//-----------------------------------------------------------------------------导出---------------------------------------------------------------------------------------------------

export default combineReducers({   // combineReducer函数：接收包含所有reducer函数的对象，返回一个新的reducer函数（总reducer）：总reducer()函数管理的state的结构为{}
  user,
  // orgInfo,
  daosDataList,  // 数据处理：曲线+道
  docData,  // 当前文件
  mbData, // 当前模板
  defaultmbData, // 默认模板
  selectedCurves,  // 选中的曲线 处理
  cancelSelected,  // 取消选中曲线
  depthDataa,
  isDraggable,  // 是否可以拖拽
  curvesCount,  // 获取计算好的最大曲线数
  updatePages,  // 实时更新页面
  videoClickYdata,  // 用户点击曲线的点坐标（y坐标）：用于同步视频播放
  videodirection,  // 视频 正反向同步 
  videoMarkline,    // 视频 标记线位置

  daosDataList1,  // 二维、三维数据展示：曲线+道
  depthDataa1,
  selectedCurves1,  
  twoDimData,
  threeDimData,
  OriginData,
  isDoNull,

  gridConfig, //栅格信息配置
   

  daosDataList2,  // 数据对比：曲线+道
  depthDataa2,
  selectedCurves2,


  hasChinaMap
  
});

